#ifndef __M_LOOP_H__
#define __M_LOOP_H__
#include "util.hpp"
#include <vector>
#include <thread>
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <functional>
#include "buffer.hpp"
//它能够同时处理多个任务，而不会让任何一个任务拖延其他任务的进度
namespace bitlog{
    class  AsyncLooper{//异步循环器
        public:
        // 使用std::function定义回调类型，接收一个Buffer引用作为参数
            using Functor = std::function<void(Buffer &buffer)>;
            // 定义智能指针类型，方便内存管理
            using ptr = std::shared_ptr<AsyncLooper>;
            // 构造函数，接收一个回调函数，并启动一个工作线程 
            AsyncLooper(const Functor &cb): _running(true), _looper_callback(cb),
                _thread(std::thread(&AsyncLooper::worker_loop, this)) {
            }
            ~AsyncLooper() { stop(); }
            // 停止异步循环器的方法
            void stop(){
                _running = false; 
                _pop_cond.notify_all();
                _thread.join();
            }
            // 向任务队列中添加消息的方法
            void push(const std::string &msg){
                if (_running == false) return;
                {
                    std::unique_lock<std::mutex> lock(_mutex);
                    _push_cond.wait(lock, [&]{ return _tasks_push.writeAbleSize() >= msg.size(); });
                    _tasks_push.push(msg.c_str(), msg.size());
                }
                _pop_cond.notify_all();
            }
        private:
        //通过在工作线程中运行worker_loop函数，AsyncLooper能够异步地处理任务，而不会阻塞主线程
            void worker_loop(){//工作循环
                while(1){
                    {
                        std::unique_lock<std::mutex> lock(_mutex);
                        if (_running == false && _tasks_push.empty()) { return; }
                        _pop_cond.wait(lock, [&]{ return !_tasks_push.empty() || !_running; });
                        _tasks_push.swap(_tasks_pop);
                    }
                    _push_cond.notify_all();
                    _looper_callback(_tasks_pop);
                    _tasks_pop.reset();
                }
                return;
            }
        private:
            Functor _looper_callback;
        private:
            std::mutex _mutex;
            std::atomic<bool> _running;
            std::condition_variable _push_cond;
            std::condition_variable _pop_cond;
            Buffer _tasks_push;
            Buffer _tasks_pop;
            std::thread _thread;
    };
}
#endif
/*异步处理：通过在工作线程中运行worker_loop函数，AsyncLooper能够异步地处理任务，而不会阻塞主线程。
线程安全：使用互斥锁（_mutex）和条件变量（_push_cond, _pop_cond）来确保对共享资源（任务队列）的访问是线程安全的。
任务队列管理：push方法允许向任务队列中添加新任务，而worker_loop则负责从队列中取出任务并处理它们。通过_tasks_push和_tasks_pop的交换，实现了任务的高效传递和处理。
灵活的回调机制：用户可以通过注册一个回调函数来定义如何处理任务。这提供了很大的灵活性，因为回调函数可以根据需要执行任何操作。
资源清理：析构函数会调用stop方法来确保在对象销毁时，工作线程被正确地停止和清理。*/